#ifndef SECUREAPIMANAGER_H
#define SECUREAPIMANAGER_H

#include <QObject>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QTimer>
#include <QJsonObject>
#include <QJsonDocument>
#include <QJsonArray>
#include <QNetworkRequest>
#include <QUrl>
#include <QStringList>
#include <QRandomGenerator>
#include <QDateTime>
#include <QCryptographicHash>
#include <QDebug>
#include "app_version.h"

/**
 * @brief 安全API管理器 - 动态端点轮换系统
 *
 * 提供多层安全保护的API通信机制：
 * - 动态端点轮换防止IP封禁
 * - 请求签名验证防止篡改
 * - 智能重试和故障转移
 * - 请求频率限制
 * - 请求/响应加密
 */
class SecureApiManager : public QObject
{
    Q_OBJECT

public:
    explicit SecureApiManager(QObject *parent = nullptr);
    ~SecureApiManager();

    // 单例模式
    static SecureApiManager& instance();

    // 端点管理
    void addApiEndpoint(const QString& endpoint, int priority = 0);
    void removeApiEndpoint(const QString& endpoint);
    QStringList getAvailableEndpoints() const;
    QString getCurrentEndpoint() const;
    void rotateEndpoint();
    void markEndpointFailed(const QString& endpoint);
    void markEndpointSuccess(const QString& endpoint);

    // 认证管理
    void setAuthToken(const QString& token);
    QString getAuthToken() const;
    bool hasValidToken() const;

    // 安全请求方法
    QNetworkReply* sendSecureRequest(const QString& endpoint,
                                   const QJsonObject& data = QJsonObject(),
                                   const QString& method = "POST",
                                   bool autoRetry = true);

    // 便捷方法（兼容现有ApiManager接口）
    void fetchUserProfile();
    void fetchUserSubscription();
    void fetchDeviceList();
    void sendHeartbeat();
    void kickDevice(const QString& sessionId);
    void logout();

    // 心跳管理
    void startHeartbeat();
    void stopHeartbeat();
    bool isHeartbeatActive() const;

    // 安全配置
    void setMaxRetryAttempts(int attempts);
    void setRequestTimeout(int milliseconds);
    void setEndpointRotationEnabled(bool enabled);
    void setRequestSigningEnabled(bool enabled);

    // 统计信息
    struct ApiStats {
        int totalRequests = 0;
        int successfulRequests = 0;
        int failedRequests = 0;
        int endpointRotations = 0;
        QDateTime lastSuccessTime;
        QDateTime lastFailureTime;
        QDateTime lastRequestTime;
        QMap<QString, int> endpointSuccessCount;
        QMap<QString, int> endpointFailureCount;
    };

    ApiStats getStatistics() const;
    void resetStatistics();

    // 端点健康检查
    void performHealthCheck();
    bool isEndpointHealthy(const QString& endpoint) const;
    QStringList getHealthyEndpoints() const;

signals:
    // 心跳相关信号
    void heartbeatSuccess();
    void heartbeatError(const QString& error);

    // 设备失效信号
    void deviceNotFound();

    // 版本更新相关信号
    void versionInfoReceived(const QString& latestVersion, const QString& downloadUrl, const QString& releaseNotes, const QString& md5Hash);

    // 用户信息相关信号
    void userProfileFetched(const QJsonObject& userProfile);
    void userSubscriptionFetched(const QJsonObject& subscription);
    void deviceListFetched(const QJsonArray& devices);

    // 错误处理信号
    void apiError(const QString& error, const QString& details);

    // 注销相关信号
    void logoutFinished(bool success);
    void networkError(const QString& error);
    void tokenExpired();

    // 设备管理信号
    void deviceKickSuccess(const QString& sessionId);
    void deviceKickError(const QString& error);

    // 端点管理信号
    void endpointRotated(const QString& oldEndpoint, const QString& newEndpoint);

private slots:
    void onRequestFinished();
    void onHeartbeatTimer();
    void onHealthCheckFinished();

private:
    // 端点管理
    struct EndpointInfo {
        QString url;
        int priority;
        bool isHealthy;
        QDateTime lastUsed;
        QDateTime lastSuccess;
        QDateTime lastFailure;
        int consecutiveFailures;
        int totalSuccesses;
        int totalFailures;

        bool operator<(const EndpointInfo& other) const {
            if (isHealthy != other.isHealthy) {
                return isHealthy > other.isHealthy;
            }
            return priority > other.priority;
        }
    };

    // 内部方法
    void initializeDefaultEndpoints();
    void loadEndpointsFromConfig();
    QString selectBestEndpoint();
    void updateEndpointStatistics(const QString& endpoint, bool success);
    QNetworkRequest buildSecureRequest(const QString& endpoint, const QJsonObject& data, const QString& method);
    QString generateRequestSignature(const QString& endpoint, const QJsonObject& data, const QString& method, qint64 timestamp);
    QString generateNonce();
    QJsonObject buildRequestPayload(const QJsonObject& data, const QString& method);
    void handleRequestError(QNetworkReply* reply, const QString& context);
    void scheduleEndpointRotation();
    double calculateEndpointScore(const QString& endpoint) const;
    QString generateDeviceFingerprint();

    // 请求重试逻辑
    struct RequestContext {
        QString endpoint;
        QJsonObject data;
        QString method;
        int attemptCount;
        QDateTime requestTime;
        bool autoRetry;
    };

    QMap<QNetworkReply*, RequestContext> m_activeRequests;

private:
    static SecureApiManager* s_instance;

    // 网络管理
    QNetworkAccessManager* m_networkManager;
    QTimer* m_heartbeatTimer;
    QTimer* m_healthCheckTimer;

    // 端点管理
    QMap<QString, EndpointInfo> m_endpoints;
    QString m_currentEndpoint;
    int m_currentEndpointIndex;
    bool m_endpointRotationEnabled;

    // 认证信息
    QString m_authToken;

    // 配置参数
    int m_maxRetryAttempts;
    int m_requestTimeout;
    bool m_requestSigningEnabled;
    int m_heartbeatInterval;

    // 心跳状态
    bool m_heartbeatActive;

    // 统计信息
    ApiStats m_statistics;

    // 常量定义
    static const int DEFAULT_RETRY_ATTEMPTS = 3;
    static const int DEFAULT_REQUEST_TIMEOUT = 30000; // 30秒
    static const int DEFAULT_HEARTBEAT_INTERVAL = 5 * 60 * 1000; // 5分钟
    static const int MAX_CONSECUTIVE_FAILURES = 3;
    static const int ENDPOINT_COOLDOWN_TIME = 60 * 1000; // 1分钟冷却
    static const QString USER_AGENT;
    static const QString API_VERSION;
};

// 端点配置结构
struct ApiEndpointConfig {
    QString url;
    int priority;
    QString region;
    QString protocol;
    int timeout;
    bool requiresAuth;
    QStringList supportedMethods;

    // 序列化
    QJsonObject toJson() const;
    static ApiEndpointConfig fromJson(const QJsonObject& json);
};

// 端点配置管理器
class EndpointConfigManager {
public:
    static EndpointConfigManager& instance();

    // 配置管理
    void loadConfiguration();
    void saveConfiguration();
    void resetToDefaults();

    // 端点配置
    void addEndpoint(const ApiEndpointConfig& config);
    void removeEndpoint(const QString& url);
    void updateEndpoint(const ApiEndpointConfig& config);
    QList<ApiEndpointConfig> getEndpoints() const;
    QList<ApiEndpointConfig> getHealthyEndpoints() const;

    // 配置验证
    bool validateEndpoint(const QString& url) const;
    bool pingEndpoint(const QString& url) const;

    // 端点轮换策略
    QString selectEndpoint(const QString& strategy = "round_robin") const;
    void markEndpointStatus(const QString& url, bool isHealthy);

private:
    EndpointConfigManager();
    ~EndpointConfigManager();

    QMap<QString, ApiEndpointConfig> m_endpoints;
    QMap<QString, bool> m_endpointHealth;
    QStringList m_endpointRotationOrder;
    int m_currentRotationIndex;

    static EndpointConfigManager* s_instance;
};

#endif // SECUREAPIMANAGER_H